			%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\documentclass[a4paper,11ptn]{report}                                   %
\usepackage[italian]{babel}                                             %
\usepackage{graphicx}                                                   %
\usepackage[colorlinks=true]{hyperref}                                  %
\usepackage{url}                                                        %
\usepackage{eurosym}                                                    %
\usepackage{lastpage}                                                   %
\usepackage{fancyhdr}                                                   %
\hypersetup{linkbordercolor=1 1 1}                                      %
\hypersetup{urlcolor=blue}                                              %
\hypersetup{linkcolor=black}                                            %
\graphicspath{{../immagini/}}                                           %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 		COMPLETARE I CAMPI VUOTI PER LA GENERAZIONE AUTOMATICA			%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newcommand{\Documento}{Definizione di Prodotto}                      % nome del documento
\newcommand{\Sommario}{Il presente documento contiene la definizione di prodotto (descrizione dettagliata delle caratteristiche tecniche ed architetturali) del progetto SiFiSy}               % sommario
\newcommand{\CodiceRevisione}{RA}                                      % revisione (es. RPP)
\newcommand{\DataCreazione}{12 febbraio 2010}                    % data di creazione
\newcommand{\Versione}{2.0}                                                % versione attuale
\newcommand{\StatoDocumento}{Formale, Esterno}                % stato (es. Formale, Interno)
\newcommand{\Redazione}{Alessandro Vedovato}                      % autore del documento
\newcommand{\Revisione}{Samuele Faggian}                         % verificatore del documento
\newcommand{\Approvazione}{Luca Zanini}                      % chi approva (responsabile)
\newcommand{\Committente}{Prof. Renato Conte, Prof. Tullio Vardanega}  % committente/i
\newcommand{\Proponente}{Dott. Claudio Palazzi}                         % proponente/i
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 			IMPOSTAZIONE DEL DOCUMENTO (NON MODIFICARE)					%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\fancypagestyle{plain}{                                                 %
\fancyhf{}                                                              %
\fancyhead[L]{\Documento\ \Versione\ - \CodiceRevisione}                            %
\fancyfoot[C]{\thepage}                                                 %
\fancyhead[R]{\includegraphics[scale=0.3]{logoSevenSoft.png}}           %
}                                                                       %
\begin{document}                                                        %
\pagenumbering{Roman}                                                   %
\begin{center}                                                          %
\includegraphics[scale=0.8]{logoSevenSoft.png} \\                       %
\vspace*{1in}                                                           %
\huge{\textbf{\textbf{\Documento}}} \\                                  %
\vspace*{2cm}                                                           %
Versione: \Versione \\                                                  %
\vspace*{3cm}                                                           %
\vspace*{0.5in}                                                         %
\textbf{Sommario} \\                                                    %
\begin{normalsize}                                                      %
\Sommario                                                               %
\end{normalsize}                                                        %
\end{center}                                                            %
\newpage                                                                %
\thispagestyle{plain}                                                   %
\vspace*{0.5in}                                                         %
\begin{center}                                                          %
\begin{tabular}{l}                                                      %
\Large{\textbf{Capitolato: Simulatore File System}} \\                  %
\begin{tabular}{|p{5cm}|p{7cm}|}                                        %
\hline                                                                  %
\textbf{Data creazione:} &  \DataCreazione \\                            %
\hline                                                                  %
\textbf{Versione:} &  \Versione \\                                       %
\hline                                                                  %
\textbf{Stato del documento:} &  \StatoDocumento \\                      %
\hline                                                                  %
\textbf{Redazione:} &  \Redazione \\                                     %
\hline                                                                  %
\textbf{Revisione:} &  \Revisione  \\                                    %
\hline                                                                  %
\textbf{Approvazione:}  &  \Approvazione \\                              %
\hline                                                                  %
\textbf{Committente:} &  \Committente \\                                 %
\hline                                                                  %
\textbf{Proponente:} &  \Proponente \\                                   %
\hline                                                                  %
\end{tabular} \\                                                        %
\end{tabular}                                                           %
\end{center}                                                            %
                                                           %
                                                     %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 		COMPLETARE I CAMPI VUOTI PER IL DIARIO DELLE MODIFICHE			%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\newpage
\thispagestyle{plain}
\begin{center}
\begin{tabular} {l}
\Large{\textbf{Legenda Diario delle modifiche}} \\
\begin{tabular}{|p{3cm}|p{7cm}|}
\hline
Vers & Versione del documento \\
\hline
Verif & Verificatore del documento \\
\hline
Resp & Responsabile che approva il documento \\
\hline
\hline
GB & Giuseppe Biolo \\
\hline
DDM & Daniele De Matteo \\
\hline
SF & Samuele Faggian \\
\hline
GF & Giuseppe Ferri \\
\hline
AL & Alberto Longato \\
\hline
AV & Alessandro Vedovato \\
\hline
LZ & Luca Zanini \\
\hline
\end{tabular} \\
\end{tabular}
\end{center}

\vspace*{2cm}

\begin{center}
\begin{tabular}{l}
\Large{\textbf{Diario delle modifiche}} \\
\begin{tabular}{|p{0.7cm}|p{1.9cm}|p{1.2cm}|p{1cm}|p{1cm}|p{6.9cm}|}
\hline
\textbf{Vers} & \textbf{Data} & \textbf{Autore} & \textbf{Verif} & \textbf{Resp} & \textbf{Descrizione} \\
\hline
2.0 & 13/07/2010 & AV & SF & LZ & Approvazione documento e passaggio stato formale per Revisione di Accettazione\\
\hline
1.3 & 09/07/2010& AV & SF & LZ & Corretti vari errori grammaticali e di significato ai metodi e alle descrizioni, aggiunto tracciamento component View\\
\hline
1.2& 06/07/2010& AV & SF & LZ & Corretta descrizione alcuni metodi ritenuti poco chiari, precisato che ogni classe ha il suo costruttore nel package Model\\
\hline
1.1& 01/07/2010& AV & SF & LZ & Sostituita la tabella Tracciamento Classi-Requisiti con una nuova piu dettagliata\\
\hline
1.0 & 21/06/2010 & GB & SF & LZ& Versione finale per Revisione di Qualifica\\
\hline
0.8 & 21/06/2010 & GB & AV & SF & Completata la parte della View \\
\hline
0.7 & 04/06/2010 & GB & DDM & LZ& Varie modifiche per migliorare il documento, corretti errori vari \\
\hline
0.6 & 28/05/2010 & GB & DDM & LZ& Modifiche varie componenti Model,View, Controller \\
\hline
0.5 & 07/05/2010 & AV& DMM& LZ& Modifiche Model, aggiunto parti del controller e della view \\
\hline
0.4 & 03/05/2010 & AV& SF&LZ& Aggiunto component View\\
\hline
0.3 &  15/04/2010& GB& SF&AV& Aggiunte classi del component Controller, modifiche al component Model  \\
\hline
0.2 &  20/02/2010& VA& SF&GB& Modifiche, perfezionamenti e aggiunte classi del component Model  \\
\hline
0.1 &  11/02/2010 & GF& VA&GB& Prima stesura del documento, inserimento metodi classi principali e spiegazioni prime componenti  \\ 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 			IMPOSTAZIONE DEL DOCUMENTO (NON MODIFICARE)					%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\hline                                                                  %
\end{tabular}      \\                                                   %
\end{tabular}       \\                                                    %
\end{center}                                                            %
\newpage                                                                %
\tableofcontents                                                        %
\newpage                                                                %
\pagenumbering{arabic}                                                  %
\fancypagestyle{plain}{                                                 %
\fancyhf{}                                                              %
\fancyhead[L]{\Documento\ \Versione\ - \CodiceRevisione}                            %
\fancyfoot[C]{\thepage\ di \pageref{LastPage}}                          %
\fancyhead[R]{\includegraphics[scale=0.3]{logoSevenSoft.png}}           %
}                                                                       %
\pagestyle{plain}                                                       %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%	COMPLETARE I CAMPI VUOTI PER IL TESTO DEL DOCUMENTO (VEDI NORME)	%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{Introduzione}

\section{Scopo del documento}
Il presente documento si propone di fornire una descrizione completa dell'architettura logica prodotta al termine della fase di progettazione architetturale. Esso descrive in dettaglio le singole
componenti che costituiscono il prodotto.


\section{Scopo del prodotto}
SiFiSy costituir\`a  un simulatore di \underline{FS} che ha come obiettivo quello di mostrare agli studenti, ma in generale a qualunque utente interessato, il funzionamento e la logica di implementazione di diversi \underline{FS}, con la possibilit\`a  di confrontare le varie configurazioni scelte e condurre alcune analisi significative.\\

\section{Glossario}
Il glossario viene fornito in un documento separato denominato \textit{Glossario} che raccoglie le definizioni, acronimi ed abbreviazioni di tutta la documentazione. I termini presenti nel glossario verranno marcati nel documento con una sottolineatura.

\section{Riferimenti}
	
\subsection{Normativi}
Per i riferimenti normativi si faccia riferimento al documento \textit{normeDiProgetto.pdf} allegato.

\subsection{Informativi}
Per i riferimenti informativi di faccia riferimento ai seguenti documenti:
\begin{itemize}
	\item[] \textit{glossario.pdf}
	\item[] \textit{pianoDiProgetto.pdf}
\end{itemize}

\chapter{Standard di progetto}
\section{Standard di progettazione architetturale}
Per quanto riguarda le rappresentazioni grafiche dell'architettura del sistema
\textit{SIFISY} ci siamo basati sulle regole definite da UML 2.0. La scelta per la stesura di suddetti diagrammi UML \`e ricaduta su Bouml 4.19.1, ed \`e stato utilizzato per:
\begin{itemize}
	\item Diagrammi Use-Case in fase di Analisi
	\item Diagrammi delle classi, di attivit\`a, di sequenza in fase di Progettazione.
\end{itemize}
La scelta \`e motivata dalla diffusione e dall'utilizzo consolidato di tale linguaggio in contesti produttivi.


\section{Standard di documentazione del codice}
Il team SevenSoft si avvarr\`a dello strumento JavaDoc specifico per il linguaggio Java utilizzato che consente di creare la documentazione necessaria per la comprensione del codice consultabile in pagine HTML.
Per una pi\`u precisa comprensione dello strumento si faccia riferimento al documento \textit{normeDiProgetto.pdf} allegato.

\section{Standard di denominazione di entit\`a e relazioni}
essendo determinante per la comprensione del flusso logico dell'applicazione dovranno essere usati nomi significativi e altre convenzioni specifiche del linguaggio.
Per ulteriori chiarimenti si rimanda al documento \textit{normeDiProgetto.pdf} allegato.

\section{Standard di programmazione}
Le regole di programmazione sono ampiamente descritte nel documento \textit{normeDiProgetto.pdf} allegato. Quindi si rimanda nuovamente ad esso per ulteriori dettagli.

\section{Strumenti di lavoro}
I seguenti strumenti verranno impiegati:
\begin{itemize}
\item NetBeans IDE 6.8: per la stesura del codice Java
\item Matis: per la creazione grafica della GUI
\item \LaTeX\ per la stesura dei documenti
\item JUnit: per i test di unit\`a
\item Javadoc: per la documentazione del codice
\end{itemize}

\chapter{Specifica delle componenti}
Il sistema \textit{SIFISY} \`e basato sul pattern MVC, descriveremo qui di seguito le componenti.\\ Verranno indicati: 
\begin{itemize}
\item l'elenco di attributi con la loro descrizione
\item i metodi con relativa descrizione sotto forma tabellare, nel quale si avr\`a, oltre alla descrizione, il nome del metodo con relativi eventuali parametri richiesti seguito dal valore restituito dal metodo. Esempio: \texttt{metodo(int parametro) : void}.
\end{itemize}
 \newpage
\section{Component Model}
Contiene una classe \texttt{Model} che contiene le simulazioni e i progetti attivi in un determinato momento nell'applicazione. Esegue i calcoli riguardanti simulazioni e progetti e notifica alla View eventuali cambiamenti di stato. Un'istanza di una particolare simulazione o progetto \`e associato a un file XML, potrebbe essere un file precedentemente salvato oppure un file di default che carica dati fissati dal sistema secondo alcuni criteri.
Di seguito sar\`a riportata un'immagine della struttura del componente Model e la descrizione di ogni singola classe.

\begin{figure}[h]
\centering
\includegraphics[scale=0.4]{generaleModel.png}
\caption{Diagramma delle classi semplificato del componente Model}
\end{figure}

\newpage
\subsection{File}
Classe che simula un vero e proprio file inserito dentro la partizione nel quale si vuole simulare il funzionamento del \underline{FS}.

\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{file.png}
\caption{Diagramma delle classi semplificato di Simulation.java}
\end{figure}

\paragraph{Attributi}
Tutti gli attributi della classe hanno visibilit\`a \texttt{private}
\begin{itemize}
	\item[]\textbf{id:} attributo di tipo stringa per l'identificazione di un oggetto \underline{file}
	\item[]\textbf{dimension:} attributo intero che contiene il riferimento numerico della grandezza del \underline{file}. Esempio: se il \underline{file} \`e grande 10 MB, l'attributo contiene il numero 10
	\item[]\textbf{exponent:} attributo intero che contiene l'esponente della potenza di 2 che identifica l'unit\`a di misura del \underline{file} (Byte, KB, MB, GB, TB)
	\item[]\textbf{averageBlocks:} attributo di tipo long che contiene la media dei blocchi del \underline{file} salvati in modo contiguo
	\item[]\textbf{size:} attributo di tipo long che contiene la grandezza del \underline{file} in Byte
	\item[]\textbf{selectedAdvanced:} attributo di tipo boolean che viene settato a \textsf{true} se l'utente decide di calcolare anche il tempo medio di lettura dei file presenti nella simulazione
\end{itemize}
	
\paragraph{Metodi}
Questa classe \`e semplicemente una classe che simula un vero file. Il suo scopo \`e quello di contenere le informazioni su \underline{file} fittizzi che vengono usati nella simulazione, non contiene particolari metodi se non i metodi per accedere agli attributi o modificarli. Questi metodi non verranno descritti in quanto il loro funzionamento \`e banale. L'unico metodo che fa dei calcoli \`e:\\
\\
getSize() : long, che resituendo un long identifica la dimensione in Byte del file.

\subsection{Section}
Classe che simula un frammento contiguo di un \underline{file}. Un file \`e composto da uno o pi\`u frammenti (Section).

\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{section.png}
\caption{Diagramma delle classi semplificato di Simulation.java}
\end{figure}

\paragraph{Attributi}
Tutti gli attributi della classe hanno visibilit\`a \texttt{private}
\begin{itemize}
	\item[]\textbf{id:} attributo di tipo stringa per l'identificazione il \underline{file} al quale il frammento appartiene
	\item[]\textbf{first:} attributo intero che contiene informazione su dove il primo blocco del frammento del \underline{file} \`e memorizzato
	\item[]\textbf{length:} attributo intero che contiene la lunghezza del frammento, insieme a \texttt{first} danno tutte le informazioni necessarie per sapere esattamente dov'\`e allocato in memoria il frammento di \underline{file}
\end{itemize}
\paragraph{Metodi}
Anche questa classe \`e semplicemente una classe che simula un frammento di file presente in memoria. Il suo scopo \`e semplicemente quello di contenere le informazioni riguardanti un determinato frammento di \underline{file} fittizzio.La classe non contiene particolari metodi se non i metodi per accedere agli attributi o modificarli. Questi metodi non verranno descritti in quanto il loro funzionamento \`e banale. La classe ha il suo costruttore.


\newpage
\subsection{Simulation}
Classe astratta che identifica una \underline{simulazione} nel sistema \textit{SIFISY}.
\begin{figure}[h]
\centering
\includegraphics[scale=0.61]{simulation.png}
\caption{Diagramma delle classi semplificato di Simulation.java}
\end{figure}

\paragraph{Attributi}
Tutti gli attributi hanno visibilit\`a \texttt{private} se non specificato diversamente nella descrizione.
\begin{itemize}
	\item[]\textbf{simName:} attributo di tipo stringa che identifica univocamente la simulazione
	\item[]\textbf{files:} vettore di oggetti \texttt{File} contenuti nella simulazione. Visibilit\`a package
	\item[]\textbf{usedBlocks:} vettore di oggetti \texttt{Section} che contiene i blocchi occupati della partizione. Visibilit\`a package
	\item[]\textbf{partitionDimension:} attributo intero che contiene il riferimento numerico della grandezza della partizione. Esempio: se la partizione \`e grande 20 GB, partitionDimension contiene il numero 20
	\item[]\textbf{partitionExponent:} attributo intero che contiene l'esponente della potenza di 2 che identifica l'unit\`a di misura della partizione (Byte, KB, MB, GB, TB)
	\item[]\textbf{blockDimension:} attributo intero che contiene il riferimento numerico della grandezza del blocco. Esempio: se il blocco \`e grande 10 KB, blockDimension contiene il numero 10
	\item[]\textbf{blockExponent:} attributo intero che contiene l'esponente della potenza di 2 che identifica l'unit\`a di misura del blocco (Byte, KB, MB, GB, TB)
	\item[]\textbf{addressDimension:} attributo intero che identifica il numero di byte necessari a indirizzare un blocco in memoria
	\item[]\textbf{fileAllocationType:} attributo intero che identifica la politica di allocazione che il \underline{FS} utilizza: First Fit, Best Fit, Worst Fit, Next Fit
	\item[]\textbf{allocationNextIndex:} attributo intero utilizzato per la politica di allocazione Next Fit che tiene traccia dell'ultimo file inserito
	\item[]\textbf{rotationSpeed:} attributo intero che identifica un'ipotetica velocit\`a di rotazione del disco sul quale risiede il \underline{FS}
	\item[]\textbf{trackPercent:} attributo intero che identifica il numero di blocchi risiedenti nella stessa traccia
	\item[]\textbf{seekTime:} attributo intero che identifica il tempo di posizionamento della testina sulla traccia desiderata
	\item[]\textbf{trackSectors:} attributo intero che identifica il numero di settori per traccia
	\item[]\textbf{maxLenghtFile:} attributo intero che identifica il file di dimensione massima che si pu\`o memorizzare il un certo \underline(FS).
	\item[]\textbf{internalFragmentation:} attributo double che identifica la media della frammentazione interna dei file del disco
	\item[]\textbf{inflationIndex:} attributo double che identifica l'indice inflattivo medio dei file contenuti in una silìmulazione
	\item[]\textbf{averageReading:} attributo intero che identifica il tempo medio di lettura di un file da disco
	\item[]\textbf{sizeFileSystem:} attributo intero che identifica la dimensione del file system utilizzato per la simulazione
	\item[]\textbf{modifiedCamps:} attributo booleano che tiene traccia se ci son state modifiche nella simulazione per eventuali salvataggi
	\item[]\textbf{chooseAdvanced:} attributo booleano che identifica la scelta di inserire i dati per le opzioni avanzate, cio\`e per il calcolo del tempo medio di lettura
\end{itemize}

\paragraph{Metodi}
Illustriamo di seguito i metodi della classe, essi hanno visibilit\`a package se non \`e scritto diversamente. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale. La classe ha il suo costruttore.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
save(Element simulationRoot) : void 		& Metodo che salva nel file XML corrispondente i dati della simulazione\\
\hline
single(Section item) : void			& Metodo che viene utilizzato per l'inserimento di una parte di file calcolando dove inserirlo in modo da creare frammentazione\\
\hline
insParts(Section section) : void		& Metodo che richiama la giusta politica di allocazione di un file per inserirne una parte\\
\hline
calculateRandomSpace() : long		& Metodo che calcola uno spazio casuale per simulare la frammentazione all'interno di un \underline{FS}\\
\hline
start()	: void					& Metodo astratto che verr\`a implementato nelle sottoclassi di Simulation\\
\hline
open(Element simulationRoot) : void 		& Metodo che carica i dati dall'XML riguardanti la classe Simulation\\
\hline
addFile(File item) : void			& Metodo per l'inserimento di un \underline{file} all'interno della simulazione e richiama il metodo di frammentazione del \underline{file}\\
\hline
breakFile(File item) : void			& Metodo che spezza il \underline{file} in frammenti di dimensione specificata dall'utente e richiama il metodo insPart(section)\\
\hline
deleteFile(String ID) : void			& Metodo per l'eliminazione di un determinato file dal vettore di file e richiama il metodo deleteParts(File item) per la cancellazione dei frammenti\\
\hline
deleteParts(File item) : void			& Metodo per l'eliminazione dei frammenti di file presenti nel vettore usedBlocks\\
\hline
viewMaxFile()	: void				& Metodo astratto che verr\`a implementato nelle sottoclassi di Simulation\\
\hline
calculateAddressDimension() : void 		& Metodo per calcolare i byte di indirizzamento dei blocchi\\
\hline
\underline{getNearestTwoPow}(int address) : int& Metodo pubblico statico che restituisce la potenza di 2 pi\`u vicina al numero dato\\
\hline
\underline{getNearestExponentOfTwo}(double address) : int& Metodo pubblico statico che restituisce a cosa devo elevare 2 per ottenere il numero ricevuto in input\\
\hline
\end{tabular}
\begin{tabular}
{|p{5cm}|p{6.4cm}|}
\hline
calculateBlockNumber() : int			& Metodo per calcolare la quantit\`a di blocchi presenti nella partizione di disco utilizzata per la simulazione\\
\hline
fragAverage() : double			&Metodo per il calcolo della media della frammentazione interna\\
\hline
calculateFileFragmentation(long sizeFile) : double&Metodo di supporto a fragAverage che calcola la frammetazione interna di un singolo file\\
\hline
firstFit(Section item) : void 			& Metodo per simulare la politica di allocazione First Fit che alloca nel primo spazio libero che trova abbastanza grande da contenere il frammento\\
\hline
bestFit(Section item) : void 			& Metodo per simulare la politica di allocazione Best Fit che alloca nel pi\'u piccolo spazio libero che trova, abbastanza grande da contenere il frammento\\
\hline
worstFit(Section item) : void 			& Metodo per simulare la politica di allocazione Worst Fit che alloca nel pi\'u grande spazio libero che trova per contenere il frammento\\
\hline
nextFit(Section item) : void 			& Metodo per simulare la politica di allocazione Next Fit che alloca nel primo spazio libero che trova dopo l'ultimo blocco inserito\\
\hline
findSpace(int first, int last, int spaceNedded) : long& Metodo che cerca dove si pu\`o inserire un file all'interno della partizione con le politiche di allocazione\\
\hline
readingTime() : double			&Metodo che calcola il tempo medio di lettura di un file\\
\hline
getConfigurationValues() : Vector	& Metodo pubblico che ritorna i valori settati sotto forma di stringa per la component View\\
\hline
getResultsValues() : Vector	& Metodo pubblico astratto implementato nelle sottoclassi\\
\hline
\end{tabular}
\end{center}
%-----------sottoclassi simulation---------------------
%\newpage
\subsection{Ext2}
Classe che simula il comportamento del \underline{FS} Ext2.
\begin{figure}[h]
\centering
\includegraphics[scale=0.65]{ext2.png}
\caption{Diagramma delle classi semplificato di Ext2.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[]\textbf{addressLevel:} contiene il livello di indirizzamento degli Inode, un diverso livello di indirizzamento consente il salvataggio di un file pi\`u o meno grande
	\item[]\textbf{firstInodeDirectBlock:} contiene il numero di blocchi del primo Inode che sono riservati alla memorizzazione dei dati
	\item[]\textbf{inodeDimension:} contiene la dimensione degli Inode del FS Ext2	
    	\item[]\textbf{inodeNumberMaxFile:} contiene il risultato del calcolo del numero di Inode necessari per il calcolo del file di dimensione massima
	\item[]\textbf{usedInodeNumber:} contiene il risultato del calcolo del numero di Inode necessari per un file

\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe essi hanno visibilit\`a package se non \`e scritto diversamente. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale. La classe ha il suo costruttore.

%TABELLA METODI EXT2
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
save(Element simulationRoot) : void 		& Metodo che salva nel file XML corrispondente i dati della simulazione\\
\hline
getInodeNumber(long sizeFile) : long 		& Metodo che calcola in base alla dimensione in Byte del file quanti Inode servono per memorizzarlo nella partizione \\
\hline
calculateMaxFile() : int 			& Metodo che calcola il numero di blocchi massimo indirizzabili dalla struttura ad Inode di Ext2.\\
\hline
inflationIndex(long sizeFile) : double 		& Metodo che calcola l'indice inflattivo di un determinato file\\
\hline
inflactionIndexAverage() : double 		& Metodo che calcola la media dell'indice inflattivo di Ext2 nella partizione di disco utilizzata prendendo l'indice inflattivo dei singoli file memorizzati\\
\hline
fileSystemDimension() : long 			& Metodo che calcola lo spazio che gli Inode occuperebbero in memoria\\
\hline
start() : void 					& Metodo che calcola i risultati di una simulazione di tipo Ext2: Massimo file memorizzabile, media indice inflattivo, numero di Inode massimo, dimensione del file system, media frammentazione interna, tempo medio di lettura da disco (se richiesto) \\
\hline
open(Element simulationRoot) : void 		& Metodo che carica i dati dall'XML riguardanti una simulazione del tipo Ext2 scelta dall'utente\\
\hline
viewMaxFile()	: void				& Metodo che calcola il file di grandezza massima memorizzabile nella partizione scelta\\
\hline
\end{tabular}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
getConfigurationValues() : Vector	& Metodo pubblico che ritorna i valori settati sotto forma di stringa per la component View\\
\hline
getResultsValues() : Vector	& Metodo pubblico che ritorna i risultati calcolati sotto forma di stringa per la component View\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA %%%%%%%%%%%%%%%%%

\subsection{Fat32}
Classe che simula il comportamento del \underline{FS} Fat 32. 
\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{fat.png}
\caption{Diagramma delle classi semplificato di Ext2.java}
\end{figure}
\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{records}: attributo di tipo double che identifica la lunghezza dei record presenti nella tabella della FAT32
	\item[] \textbf{sizeFileSystem}: attributo di tipo double che contiene la dimensione del file system FAT32
	\item[] \textbf{maxPartitionSize}: attributo di tipo long che contiene la dimensione massima di una partizione per il quale FAT 32 funziona.

\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe, essi hanno visibilit\`a package se non \`e scritto diversamente. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale. La classe ha il suo costruttore.
%TABELLA METODI FAT
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
open(Element simulationRoot) : void		&Metodo che carica i dati dall'XML riguardanti la simulazione del tipo Fat32 \\
\hline
save(Element simulationRoot) : void		&Metodo che salva nel file XML corrispondente i dati della simulazione\\
\hline
start() : void					& Metodo che calcola i risultati di una simulazione di tipo Fat32: media indice inflattivo, dimensione del file system, frammentazione interna, tempo medio lettura di un file\\
\hline
inflationIndex(long sizeFile) : double 		& Metodo che calcola l'indice inflattivo di un determinato file\\
\hline
getFileMaxSize() : double			& Metodo che restituisce la dimensione massima di un file all'interno del file system\\
\hline
getFat32Dim() : double			& Metodo che calcola lo spazio che la tabella della FAT occuperebbero in memoria\\
\hline
viewMaxFile()	: void				& Metodo che calcola il file di grandezza massima memorizzabile nell'hard disk\\
\hline
getConfigurationValues() : Vector	& Metodo pubblico che ritorna i valori settati sotto forma di stringa per la component View\\
\hline
getResultsValues() : Vector	& Metodo pubblico che ritorna i risultati calcolati sotto forma di stringa per la component View\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA

\newpage %%%%%%%%%%%%%%%%%
\subsection{Ntfs}
Classe che simula il comportamento del \underline{FS} Ntfs.
\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{ntfs.png}
\caption{Diagramma delle classi semplificato di Ntfs.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{baseRecord:} attributo intero che contiene lo spazio necessario per l'indirizzamento dei blocchi nel record base
    	\item[] \textbf{extensionRecord:} attributo intero che contiene lo spazio necessario per l'indirizzamento dei blocchi nel record estensione
	\item[] \textbf{baseRecordCouples:} attributo intero che identifica il numero delle coppie inizio - lunghezza presenti nel record base
	\item[] \textbf{extensionRecordCouples:} attributo intero che identifica l numero delle coppie inizio - lunghezza presenti nel record estensione
	\item[] \textbf{recordsOccupied:} attributo di tipo long che contiene i record attualmente occupati per NTFS
\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe, essi hanno visibilit\`a package se non \`e scritto diversamente. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale. La classe ha il suo costruttore.
%TABELLA METODI NTFS
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
inflactionIndexAverage() : double 		& Metodo che calcola la media dell'indice inflattivo di ext2 nella partizione di disco utilizzata prendendo l'indice inflattivo dei singoli file memorizzati\\
\hline
fileSystemDimension() : int			& Metodo che calcola lo spazio che i record delle tabelle occuperebbero in memoria\\
\hline
start() : void					& Metodo che calcola i risultati di una simulazione di tipo NTFS: Massimo file memorizzabile, media indice inflattivo, dimensione del file system, media frammentazione interna, tempo medio di lettura dei file\\
\hline
getRecordsNumber(String id) : int		&Metodo che in base alla simulazione restituisce il numero di record che compongono il \underline{FS} di tipo NTFS\\
\hline
getFileRecordsComposition() : Vector		&Metodo che restituisce un array di coppie di interi, ogni coppia del primo file incluso (inizio e lunghezza). Imposta inoltre il numero di coppie presenti nel record di base e di quelle contenute nel record di estensione\\
\hline
open(Element simulationRoot) : void		&Metodo che carica i dati dall'XML riguardanti la simulazione del \underline{FS} di tipo NTFS \\
\hline
save(Element simulationRoot) : void		&Metodo che salva nel file XML corrispondente i dati della simulazione\\
\hline
viewMaxFile()	: void				& Metodo che calcola il file di grandezza massima memorizzabile nell'hard disk\\
\hline
getConfigurationValues() : Vector	& Metodo pubblico che ritorna i valori settati sotto forma di stringa per la component View\\
\hline
getResultsValues() : Vector	& Metodo pubblico che ritorna i risultati calcolati sotto forma di stringa per la component View\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA

%-----------END sottoclassi simulation-----------------
\newpage
\subsection{Project}
Classe che raccoglie e gestisce un insieme di \underline{simulazioni} nel sistema \textit{SIFISY} e che ne calcola il confronto sulla base delle simulazioni scelte dall'utente all'interno della classe project.

\begin{figure}[h]
\centering
\includegraphics[scale=0.75]{project.png}
\caption{Diagramma delle classi semplificato di Project.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{name:} attributo stringa che contiene il nome del progetto
	\item[] \textbf{simulationsRef:} vettore di tipo \texttt{Integer} che contiene gli indici delle simulazioni presenti nel progetto
	\item[] \textbf{compare:} vettore di tipo \texttt{Integer} che contiene gli indici delle simulazioni presenti nel progetto che l'utente vuole confrontare tra loro
    	\item[] \textbf{modified:} attributo booleano che tiene traccia se \`e stato modificato o no il progetto
	\item[] \textbf{bestCompare:} vettore di tipo \texttt{Integer} che contiene gli indici delle simulazioni che hanno il miglior risultato in un determinato confronto (Esempio: minor frammentazione interna)
\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale. La classe ha il suo costruttore.
%TABELLA METODI Project
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
numberOfSimulation() : int			& Metodo pubblico che ritorna il numero di simulazioni presenti vettore di simulazioni\\
\hline
save(Element projectRoot) : void		&Metodo pubblico che salva nel file XML corrispondente i dati del progetto\\
\hline
open(Element projectRoot) : void		&Metodo pubblico che carica i dati dall'XML riguardanti il progetto\\
\hline
addSimulation(Integer simulationId)() : void	& Metodo pubblico che aggiunge l'indice di una simulazione al vettore di simulazioni presente nella classe Project\\
\hline
importSimulation(String filePath) : int		& Metodo pubblico che importa una simulazione esistente nel progetto e ne ritorna l'indice\\
\hline
importSimulation(String filePath, SimulationPanel panel) : void & Metodo pubblico che importa una simulazione esistente nel progetto e notifica alla component View\\
\hline
removeSimulation(int simId)() : void		& Metodo pubblico che elimina l'indice di una simulazione dal vettore di indici presente nella classe Project\\
\hline
getSimulation(int simId) : Integer		& Metodo pubblico che ritorna l'indice di una determinata simulazione\\
\hline
addCompare(Integer SimId) : void		& Metodo pubblico che aggiunge l'indice di una simulazione al vettore di indici di simulazioni da confrontare\\
\hline
removeCompare(Integer simId) : void	& Metodo pubblico che rimuove un'indice dal vettore \textsf{compare}\\
\hline
compare() : void				&Metodo pubblico che richiama i metodi che effettuano il calcolo comparativo delle simulazioni\\
\hline
compareOverhead() : void			& Metodo pubblico che confronta le simulazioni in base all'indice inflattivo del file system e salva nel vettore \textsf{bestCompare} l'indice della simulazione con overhead minore\\
\hline
compareMaxLenghtFile() : void		& Metodo pubblico che confronta le simulazioni in base al file di dimensione massima che si pu\`o salvare e salva nel vettore \textsf{bestCompare} l'indice della simulazione con file di dimensione maggiore\\
\hline
\end{tabular}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
compareFileSystem() : void			&Metodo pubblico che confronta le simulazioni in base alla dimensione del file system e salva nel vettore \textsf{bestCompare} l'indice della simulazione con file system minore\\
\hline
compareInternalFragmentation() : void	&Metodo pubblico che confronta le simulazioni in base alla frammentazione media dei file e salva nel vettore \textsf{bestCompare} l'indice della simulazione con file system minore\\
\hline
\end{tabular}
\end{center}
%FINE TABELLA

\newpage
\subsection{Model}
Classe che gestisce tutti i flussi in entrata al Component Model indirizzandoli correttamente per avere poi risultati corretti.

\begin{figure}[h]
\centering
\includegraphics[scale=0.695]{modelClass.png}
\caption{Diagramma delle classi semplificato di Model.java}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{simulations:} vettore statico privato che contiene le simulazioni aperte dall'utente
	\item[] \textbf{project:} vettore statico privato che contiene i progetti aperti dall'utente
   	\item[] \textbf{language:} attributo statico e privato che contiene la lingua scelta dall'utente che dovr\`a essere caricata dai file XML.
	\item[] \textbf{schemaPath:} attributo statico e privato che contiene la path dello schema di validazione dei file XML di simulazioni e progetti
	\item[] \textbf{setupPath:} attributo statico, privato e costante che carica le impostazioni di default
	\item[] \textbf{guiTranslatePath:} attributo statico e privato che contiene la path del file XML contenente le traduzioni dei messaggi di sistema
	\item[] \textbf{startupScreen:} attributo statico e privato che indica se la schermata di avvio deve essere visualizzata o meno
	\item[] \textbf{getHelpPath:} attributo statico e privato che contiene la path del file XML contenete i messaggi di help
	\item[] \textbf{defaultSimulationPath:} attributo statico e privato che contiene la path della simulazione di default
\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale. La classe ha il suo costruttore.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
\underline{loadSetup} () : void & Metodo pubblico che carica la simulazione desiderata\\
\hline
\underline{saveSetup} () : void & Metodo pubblico che salva la simulazione selezionata\\
\hline
\underline{translate} (String message) : String & Metodo pubblico che traduce la stringa passata come parametro\\
\hline
\underline{help} (String message) : String & Metodo pubblico che traduce la stringa passata come parametro\\
\hline
\underline{newSimulation} (String name, SimulationPanel panel) : void & Metodo pubblico che crea una nuova simulazione e che la inserisce nel vettore di simulazioni\\
\hline
\underline{openSimulation} (String path, SimulationPanel panel) : void & Metodo pubblico che apre una simulazione esistente e la inserisce nel vettore di simulazioni\\
\hline
\underline{resetToDefault} (int simulationId, SimulationPanel panel) : void & Metodo pubblico che ricarica la simulazione di default\\
\hline
\underline{switchFileSystem} (int simulationId, String fileSystemType) : void & Metodo pubblico che cambia il tipo di file system della simulazione\\
\hline
\underline{saveSimulation} (int index, String path, SimulationPanel panel) : void & Metodo pubblico che salva la simulazione selezionata dall'utente\\
\hline
\underline{startSimulation} (int simId, SimulationPanel panel) : void & Metodo pubblico che richiama l'avvio della simulazione selezionata dall'utente\\
\hline
\underline{removeSimulation} (int simId, SimulationPanel panel) : void & Metodo che rimuove una simulazione dal vettore di simulazioni\\
\hline
\underline{exportSimulationPng} (String simPath, SimulationPanel panel) throws java.io.FileNotFoundException : void & Metodo pubblico che esporta in png i grafici e i risultati della simulazione\\
\hline
\underline{exportSimulationPdf} (String simPath, SimulationPanel panel) : void & Metodo pubblico che esporta in pdf i risultati della simulazione\\
\hline
\underline{newProject} (String name, ProjectPanel panel) : void & Metodo pubblico statico che crea un nuovo progetto e lo inserisce nel vector di progetti\\
\hline
\underline{addSimulation} (String simName, SimulationPanel panel, int projectId) : void & Metodo pubblico statico che crea una simulazione e la aggiunge al vettore di progetti\\
\hline
\underline{openProject} (String path, ProjectPanel panel) : void & Metodo pubblico statico che apre un progetto precedentemente salvato\\
\hline
\underline{saveProject} (int prjId, String path, ProjectPanel panel) : void & Metodo pubblico statico che salva un progetto nell'xml presente nel vettore di progetti\\
\hline
\end{tabular}
\end{center}




\section{Componente View}
Implementa l'interfaccia Observer ed estende la classe astratta Observable. \\
Contiene lo stato a cui il Controller, in quanto suo Observer, \`e interessato.  \\
Inoltra una notifica al Controller quando il proprio stato si modifica in seguito alle richieste dei client, le quali risultano opportunamente tradotte in transizioni verso il Controller, con l'utilizzo opportuno del pattern Command.  \\
Di seguito sar\`a riportata un'immagine della struttura del componente View e la descrizione di ogni singola classe. Ogni classe contiene il suo costruttore.

\begin{figure}[h]
\centering
\includegraphics[scale=0.45]{View.png}
\caption{Diagramma delle classi semplificato della componente View}
\end{figure}

\newpage

\subsection{MainWidget}
Classe che rappresenta la schermata principale della GUI, e che permette all'utente di interagire con le funzionalit\`a generiche accessibili dalla GUI.

\begin{figure}[h]
\centering
\includegraphics[scale=0.45]{MainWidget.png}
\caption{Diagramma delle classe MainWidget}
\end{figure}

\paragraph{Attributi}
Gli attributi della classe sono tutti privati a meno di esplicita specifica.
\begin{itemize}
	\item[] \textbf{FILEFILTER PDF:} campo dati pubblico, statico e costante che permette di filtrare i file con estensione PDF
	\item[] \textbf{FILEFILTER SIMULATION:} campo dati pubblico, statico e costante che permette di filtrare i file contenenti una simulazione
	\item[] \textbf{FILEFILTER PROJECT:} campo dati pubblico, statico e costante che permette di filtrare i file conteneti un progetto
	\item[] \textbf{FILEFILTER PNG:} campo dati pubblico, statico e costante che permette di filtrare i file con estensione PNG
	\item[] \textbf{simulations: } vector di SimulationsPanel che contiene tutti i pannelli per la gestione delle singole simulazioni aperte
	\item[] \textbf{simulationsList: } vector statico di String che contiene la lista dei nomi delle simulazioni aperte; necessario per la corretta visualizzazione dell'albero di navigazione
	\item[] \textbf{projectsList: } vector statico di String che contiene la lista dei nomi dei progetti aperti; necessario per la corretta visualizzazione dell'albero di navigazione
	\item[] \textbf{tabbedPane: } campo dati statico di tipo JTabbedPane che permette la gestione, mediante tab, delle simulazioni e dei progetti aperti
	\item[] \textbf{treeView: } capo dati statico di tipo JTree che rappresenta l'albero di navigazione
	\item[] \textbf{mainWidgetFrame: } campo dati statico di tipo JFrame che rappresenta il frame principale della GUI
	\item[] \textbf{fileMenu: } attributo che rappresenta il men\`u a tendina della schermata principale
	\item[] \textbf{file: } attributo che rappresenta la voce ''File'' del men\`u ''fileMenu''
	%\item[] \textbf{simulation: } attributo che rappresenta la voce ''Simulazione'' del men\`u ''fileMenu''
	%\item[] \textbf{project: } attributo che rappresenta la voce ''Progetto'' del men\`u ''fileMenu''
	\item[] \textbf{help: } attributo che rappresenta la voce ''Help'' del men\`u ''fileMenu''
	\item[] \textbf{newSimulation: } attributo che rappresenta la voce ''Nuova Simulazione'' del men\`u ''file'' 
	\item[] \textbf{newProject: } attributo che rappresenta la voce ''Nuovo Progetto'' del men\`u ''file''
	\item[] \textbf{wizard: } attributo che rappresenta la voce ''Mostra Wizard'' del men\`u ''file''
	\item[] \textbf{open: } attributo che rappresenta la voce ''Apri'' del men\`u ''file''
	\item[] \textbf{closeSimulation: } attributo che rappresenta la voce ''Chiudi Simulazione'' del men\`u ''file''
	\item[] \textbf{closeProject: } attributo che rappresenta la voce ''Chiudi Progetto'' del men\`u ''file''
	\item[] \textbf{save: }  attributo che rappresenta la voce ''Salva'' del men\`u ''file''
	\item[] \textbf{saveAs: } attributo che rappresenta la voce ''Salva con nome..'' del men\`u ''file''
	\item[] \textbf{preferences: } attributo che rappresenta la voce ''Preferenze'' del men\`u ''file''
	\item[] \textbf{exit: } attributo che rappresenta la voce ''Esci'' del men\`u ''file''
	%\item[] \textbf{startSimulation: } attributo che rappresenta la voce ''Avvia Simulazione'' del men\`u ''simulation''
	%\item[] \textbf{parameters: } attributo che rappresenta la voce ''Parametri'' del men\`u ''project''
	%\item[] \textbf{startComparison: } attributo che rappresenta la voce ''Avvia Confronto'' del men\`u ''project''
	\item[] \textbf{helpWizard: } attributo che rappresenta la voce ''Help'' del men\`u ''help''
	\item[] \textbf{about: } attributo che rappresenta la voce ''About'' del men\`u ''help''
	\item[] \textbf{newSimulationButton: } attributo che rappresenta il pulsante per creare una nuova simulazione posto sulla schermata principale
	\item[] \textbf{newProjectButton: } attributo che rappresenta il pulsante per creare un nuovo progetto posto sulla schermata principale
	\item[] \textbf{openButton: } attributo che rappresenta il pulsante per aprire una simulazione o un progetto posto sulla schermata principale
	\item[] \textbf{saveButton: } attributo che rappresenta il pulsante per salvare una simulazione o un progetto posto sulla schermata principale
	\item[] \textbf{saveAsButton: } attributo che rappresenta il pulsante per salvare con nome una simulazione o un progetto posto sulla schermata principale
	\item[] \textbf{helpButton: } attributo che rappresenta il pulsante per richiamare l'help posto sulla schermata principale
	%\item[] \textbf{nowOpen: } attributo che rappresenta la lista delle simulazioni e dei progetti attualmente aperti; necessario per il funzionamento dell'albero di navigazione
	\item[] \textbf{messages: } attributo che rappresenta la schermata dove compaiono i messaggi di errore del programma
	\item[] \textbf{rootNode: } attributo che rappresenta il nodo principale dell'albero di navigazione
\end{itemize}
\paragraph{Metodi}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
initComponets () : void & Metodo privato che inizializza tutti gli attributi globali della classe \\
\hline
\underline{open} () : boolean & Metodo publico che visualizza una schermata che permette all'utente di aprire una simulazione o un progetto esistente \\
\hline
initTreeView () : void & Metodo privato che inizializza l'albero per la gestione grafica delle simulazioni e dei progetti aperti \\
\hline
\underline{updateTreeView} () : void & Metodo publico che permette di aggiornare il contenuto dell'albero per la gestione grafica delle simulazioni e dei progetti aperti nel caso qualche componente esterno alla classe ne modifichi il contenuto \\
\hline
\underline{getNodeIndex} (String nodeName) : int & Metodo privato che restituisce l'indice di un nodo, datone il nome, all'interno dell'albero per la gestione grafica delle simulazioni e dei progetti aperti \\
\hline
mainWidget () & Costruttore pubblico della classe \\
\hline
\underline{addSimulationToTree} (SiFiSyTreeNode node) : void & Metodo pubblico che inserisce un nodo nell'albero di navigazione; il nodo pu\`o rappresentare una simulazione o un progetto \\
\hline
\underline{addSimulationToTree} (SifisyTreeNode node, DefaultMutableTreeNode parentNode) : void & Metodo pubblico per inserire un sotto-nodo nell'albero di navigazione; il nodo padre rappresenta un progetto, mentre il nodo che si inserisce un progetto \\
\hline
\underline{removeSimulation} (SimulationPanel simPanel) : void & Metodo pubblico per eliminare il pannello di una simulazione dalla lista delle tab nella schermata principale \\
\hline
removeSimulationFromList ( String name) : void & Metodo pubblico per eliminare una simulazione dalla lista delle delle simulazioni aperte utilizzando come chiave il nome della simulazione \\
\hline
removeProjectFromList (String name) : void & Metodo pubblico per eliminare un progetto dalla lista delle dei progetti aperti utilizzando come chiave il nome del progetto \\
\hline
\end{tabular}
\end{center}
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
%\hline
%\textbf{Nome} & \textbf{Descrizione}\\
\hline
\underline{showOpenFileDialog} (int fileFilter) : String & Metodo pubblico che apre una schermata che permette di selezionare un file da aprire (simulazione o progetto); i file vengono filtrati in base al filtro rappresentato dall'attributo fileFilter; ritorna la path assoluta del file selezionato \\
\hline
\underline{showSaveFileDialog} (int fileFilter) : String & Metodo publico che apre una schermata che permette di indicare il nome del file e la path dove si desidera salvare la simulazione o il progetto; i file vengono filtrati in base al filtro rappresentato dall'attributo fileFilter; ritorna la path assoluta del file selezionato \\
\hline
\underline{createSimulation} (String simulationName) : SimulationPanel & Metodo pubblico che crea una nuova simulazione ed aggiunge il pannello che la rappresenta alla schermata principale; ritorna il SimulationPanel appena creato \\
\hline
\underline{createSimulation} (String simulationName, ProjectPanel panel) : SimulationPanel & Metodo pubblico che crea una nuova simulazione e la aggiunge al pannello che rappresenta il progetto indicato dal parametro panel; ritorna il SimulationPanel appena creato \\
\hline
\underline{createProject} (String projectName) : ProjectPanel & Metodo pubblico che crea un nuovo progetto ed aggiunge il pannello che lo rappresenta alla schermata principale; ritorna il ProjectPanel appena creato \\
\hline
\underline{main} () : void & Metodo pubblico che avvia il programma \\
\hline
\end{tabular}
\end{center}

\newpage



\subsection{SimulationPanel}
Classe che rappresenta il pannello che permette la completa gestione di una simulazione aperta.

\begin{figure}[h]
\centering
\includegraphics[scale=0.6]{SimulationPanel.png}
\caption{Diagramma delle classe SimulationPanel}
\end{figure}


\paragraph{Attributi della classe SimulationPanel}
Gli attributi della classe sono tutti privati.
\begin{itemize}

	\item[] \textbf{CONFIG PANEL: } attributo statico e costante che rappresenta il pannello di configurazione della simulazione
	\item[] \textbf{RESULTS PANEL: } attributo statico e costante che rappresenta il pannello dei risultati della simulazione
	\item[] \textbf{simulationId: } attributo che contiene l'id della simulazione nel vector delle simulazioni della classe Model
	\item[] \textbf{simulationName: } attributo che contiene il nome della simulazione
	\item[] \textbf{simulationManager: } attributo che rappresenta il Controller collegato al pannello
	\item[] \textbf{node: } attributo che rappresenta il nodo dell'albero di navigazione relativo alla simulazione del pannello
	\item[] \textbf{parentPanel: } attributo che rappresenta il pannello a cui appartiene la simulazione; serve per distinguere il caso di simulazioni normali o simulazioni contenute in un progetto
	\item[] \textbf{configSimulation: } attributo che rappresenta il pulsante presente nel pannello che permette di configurare la simulazione
	\item[] \textbf{startSimulation: } attributo che rappresenta il pulsante presente nel pannello che permette di avviare la simulazione
	\item[] \textbf{simulationGraphics: } attributo che rappresenta il pulsante presente nel pannello che permette di visualizzare graficamente i risultati della simulazione
	\item[] \textbf{exportResults: } attributo che rappresenta il pulsante presente nel pannello che permette di esportare la simulazione in formato PDF
	\item[] \textbf{resetSimulation: } attributo che rappresenta il pulsante presente nel pannello che permette di riportare i campi dati della simulazione ai valori della simulazione di default
	\item[] \textbf{setAsDefaultSimulation: } attributo che rappresenta il pulsante presente nel pannello che permette di salvare come default la simulazione
	\item[] \textbf{closeSimulation: } attributo che rappresenta il pulsante presente nel pannello che permette di chiudere la simulazione
	\item[] \textbf{changeFileInsertionMode: } attributo che rappresenta il pulsante che permette di passare dalla modalit\`a di inserimento di un file singolo alla modalit\`a per l'inserimento di file multipli
	\item[] \textbf{model: } attributo che rappresenta la tabella riassuntiva dei file inseriti (solo in modalit\`a per l'inserimento di file multipli)
	\item[] \textbf{resultsPanel: } attributo che rappresenta il pannello con i risultati della simulazione
	\item[] \textbf{frameGraphics: } attributo che rappresenta la schermata con i risultati grafici della simulazione
	\item[] \textbf{activePanel: } attributo che indica il pannello interno attualmente visibile; puo' essere il pannello di configurazione o quello per la visualizzazione dei risultati
\end{itemize}

\paragraph{Metodi della classe SimulationPanel}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
initComponents () :  void & Metodo privato che inizializza tutti gli attributi globali della classe \\
\hline
clearFields () : void & Metodo pubblico che elimina tutti i segnali di errore dalla schermata; usato solo in congiunzione alla funzione refreshFields nel caso di resetToDefault della simulazione \\
\hline
readSimulationValues () : void & Metodo pubblico che legge dal model i campi dati della simulazione e li inserisce nei relativi campi del pannello \\
\hline
SimulationPanel () & Costruttore di default della classe; ha corpo vuoto e viene utilizzato unicamente per poter eseguire i test automatizzati sul codice \\ 
\hline
SimulationPanel (String name, SiFiSyTreeNode node) & Costruttore della classe che attribuisce il nome della simulazione mediante il parametro name e il nodo dell'albero di navigazione relativo alla simulazione \\
\hline
SimulationPanel (String simName, SifisyTreeNode node, ProjectPanel parent) & Costruttore della classe che attribuisce il nome della simulazione mediante il parametro name, il nodo dell'albero di navigazione relativo alla simulazione tramite il parametro node e il pannello padre tramite il parametro parent; viene usato per l'aggiunta di una simulazione ad un progetto \\
\hline
loadSimulationFiles () : void & Metodo publico che permette di caricare i file contenuti in una simulazione; usato solo se si \`e nella modalit\`a per l'inserimento di file multipli \\
\hline
showConfig () : void & Metodo pubblico che rende visibile il pannello contenente la configurazione della simulazione e rende non visibile il pannello per visualizzare i risultati \\
\hline
showResults () : void & Metodo pubblico che rende visibile il pannello che permette di visualizzare i risultati e rende non visibile quello per la configurazione della simulazione \\
\hline
lockWindowsDialog (boolean active) : void & Metodo che permette di bloccare il pannello rendendo impossibile per l'utente di modificare i campi dati \\
\hline
\end{tabular}
\end{center}
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
%\textbf{Nome} & \textbf{Descrizione}\\
%\hline
notifyPanel (int simId) : void & Metodo pubblico che sblocca il pannello e setta il valore del campo dati simulationId al valore del parametro simId \\
\hline
notifyPanel (String message) : void & Metodo pubblico che sblocca il pannello e visualizza un eventuale messaggio di errore contenuto nel parametro message \\
\hline
notifyPanel () : void & Metodo pubblico che sblocca il pannello \\
\hline
refreshFields () : void & Metodo pubblico che ricarica i valori dei campi dati della simulazione leggendoli dal Model \\
\hline
\end{tabular}
\end{center}

\paragraph{Attributi della classe interna SimulationResultsPanel}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{settingsTable: } attributo che rappresenta la tabella contenente la configurazione della simulazione
	\item[] \textbf{tableModel: } attributo che rappresenta la struttura interna della tabella; necessario per inserire ed eliminare le diverse voci
	\item[] \textbf{settingsScrollPane: } attributo che rappresenta il pannello contenente la tabella dei settaggi
	\item[] \textbf{resultsTable: } attributo che rappresenta la tabella contenente i risultati della simulazione
	\item[] \textbf{resultsModel: } attributo che rappresenta la struttura per gestire la tabella che contiene i risultati della simulazione
	\item[] \textbf{resultsScrollPane: } attributo che rappresenta il pannello contenente la tabella dei risultati
	\item[] \textbf{parentPane: } attributo che rappresenta il pannello della simulazione che si e' simulata

\end{itemize}

\paragraph{Metodi della classe interna SimulationResultsPanel}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
SimulationResultsPanel (SimulationPanel parent) & E' il costruttore della classe; prende come attributo il SimulationPanel nel quale deve essere inserito \\
\hline
initComponents () : void & Metodo privato per inizializzare tutte le variabili globali della classe \\
\hline
fillResultsTable () : void & Metodo publico per caricare i dati all'interno della tabella \\
\hline
\end{tabular}
\end{center}



\subsection{ProjectPanel}
Classe che rappresenta il pannello che permette la completa gestione di un progetto aperto.

\begin{figure}[h]
\centering
\includegraphics[scale=0.7]{ProjectPanel.png}
\caption{Diagramma delle classe ProjectPanel}
\end{figure}

\paragraph{Attributi della classe ProjectPanel}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{projectId: } attributo che contiene l'id che identifica il progetto nel Vector del Model
	\item[] \textbf{projectName: } attributo che contiene il nome del progetto
	\item[] \textbf{projectManager: } attributo che rappresenta il Controller legato al pannello
	\item[] \textbf{node: } attributo che rappresenta il nodo relativo al progetto all'interno dell'albero di navigazione
	\item[] \textbf{panelCompare: } attributo che rappresenta il pannello che contiene i risultati dei confronti fra due o piu' simulazioni
	\item[] \textbf{toolBar: } attributo che rappresenta la barra con i pulsanti presente nel pannello
	\item[] \textbf{buttonAddSimulation: } attributo che rappresenta il bottone per aggiungere una simulazione
	\item[] \textbf{buttonClose: } attributo che rappresenta il bottone per chiudere la simulazione
	\item[] \textbf{buttonImportSimulation: } attributo che rappresenta il bottone per importare una simulazione esistente all'interno del progetto
	\item[] \textbf{tabbedPane: } attributo che rappresenta la schermata principale dotata di scroll verticale
\end{itemize}

\paragraph{Metodi della classe ProjectPanel}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
initComponents () : void & Metodo privato che inizializza tutti i campi dati privati della classe \\
\hline
ProjectPanel (String projectName, SifisyTreeNode node) & Costruttore della classe; attraverso gli attributi viene settato il nome del progetto e il nodo dell'albero di navigazione relativo al progetto \\
\hline
lockWindowsDialog (boolean active) : void & Metodo pubblico che permette di bloccare e sbloccare il pannello, rendendo possibile o meno che l'utente modifichi i campi dati \\
\hline
notifyPanel (int projectId) : void & Metodo pubblico che sblocca il pannello e setta il valore del ''projectId'' al valore del parametro ''projectId'' \\
\hline
notifyPanel (String message) : void & Metodo pubblico che sblocca il pannello e visualizza il messaggio che viene passato grazie al parametro ''message'' \\
\hline
notifyPanel () : void & Metodo pubblico che sblocca la grafica \\
\hline
addSimulation (String simulationName, SifisyTreeNode simulationNode) : SimulationPanel & Metodo pubblico che aggiunge una nuova simulazione alla classe; restituisce il SimulationPanel della simulazione inserita \\
\hline
removeSimulation (SimulationPanel simPanel) : void & Metodo pubblico che rimuove una simulazione dal progetto, identificandola grazie al suo pannello, passato come parametro \\
\hline
refreshFields () : void & Metodo pubblico che ricarica i valori nella tabella del progetto leggendoli dal Model \\
\hline
\end{tabular}
\end{center}


\paragraph{Attributi della classe interna ProjectComparePanel}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{CONFIG PANEL: } attributo che contiene l'identificativo del pannello di configurazione dei confronti
	\item[] \textbf{RESULTS PANEL: } attributo che contiene l'identificativo del pannello dei risultati dei confronti
	\item[] \textbf{parentPanel: } attributo che rappresenta il ProjectPanel nel quale verr\`a inserito il ProjectComparePanel
	\item[] \textbf{toolBar: } attributo che rappresenta la toolbar presente nel pannello
	\item[] \textbf{btConfigProject: } attributo che rappresenta il bottone per visualizzare il pannello di configurazione del progetto
	\item[] \textbf{btStartProject: } attributo che rappresenta il bottone per avviare il progetto
	\item[] \textbf{btExportPdf: } attributo che rappresenta il bottone per l'esportazione in PDF
	\item[] \textbf{panelInner: } attributo che rappresenta il pannello dei risultati del confrontl
	\item[] \textbf{panelConfig: } attributo che rappresenta il pannello di configurazione del confronto
	\item[] \textbf{selectedSimulations: } 
	\item[] \textbf{listModel: } attributo che rappresenta la struttura interna della tabella per la visualizzazione dei risultati delle simulazioni
	\item[] \textbf{resultsPanel: } attributo che rappresenta il pannello nel quale viene visualizzata la tabella dei risultati  
	\item[] \textbf{resultsTable: } attributo che rappresenta la tabella contenente i risultati delle simulazioni avviate, e che permette di confrontare i risultati
	\item[] \textbf{tableModel: } attributo che rappresenta la struttura interna della tabella dei risultati
\end{itemize}

\paragraph{Metodi della classe interna ProjectComparePanel}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
ProjectComparePanel (ProjectPanel parentPanel) & Costruttore della classe; attraverso il parametro parentPanel si indica il ProjectPanel nel quale il ProjectComparePanel sara' inserito e poi visualizzato \\
\hline
initComponents () : void & Metodo privato per inizializzare tutti i campi dati globali della classe \\
\hline
addSimulation (int simulationId) : void & Metodo publico che aggiunge una simulazione alla lista delle simulazioni da eseguire per poi effettuare il confronto \\
\hline
removeSimulation (int simulationId) : void & Metodo publico che rimuove la simulazione identificata dall'attributo ''simulationId'' dalla lista delle simulazioni da eseguire per poi effettuare il confronto \\
\hline
fillResultsTable () : void & Metodo publico per caricare i dati all'interno della tabella \\
\hline
\end{tabular}
\end{center}

\paragraph{Attributi della classe interna SifisyTableCellRenderer}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{cellColor: } attributo che contiene il colore di sfondo della cella nella tabella
\end{itemize}

\paragraph{Metodi della classe interna SifisyTableCellRenderer}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
SifisyTableCellRenderer (Color cellColor) & Costruttore della classe; attraverso il parametro cellColor si indica il colore di sfondo della cella nella tabella \\
\hline
getTableCellRendererComponent (JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) : Component & Override del metodo pubblico che si occupa di disegnare una cella nella tabella \\
\hline
\end{tabular}
\end{center}

\paragraph{Attributi della classe interna SifisyTableCell}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{value: } attributo che contiene il valore da visualizzare nella cella
	\item[] \textbf{isColored: } attributo che specifica se la cella corrente deve essere colorata con un colore diverso da quello standard della tabella
\end{itemize}

\paragraph{Metodi della classe interna SifisyTableCell}
Illustriamo di seguito i metodi della classe. Ogni variabile privata indicata sopra avr\`a i suoi rispettivi metodi pubblici per modificarla e leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.
\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
SifisyTableCell (String value, boolean isColored) & Costruttore della classe; attraverso il parametro value si specifica il valore da visualizzare nella cella mentre, attraverso il parametro isColored, si indica se la cella deve essere colorata \\
\hline
toString () : String & Override del metodo pubblico che si occupa di restituire il corrispondente valore stringa della cella \\
\hline
\end{tabular}
\end{center}


%-----------------CONTROLLER----------------------
\section{Componente Controller}
Memorizza un riferimento all'oggetto View.  \\
Contiene informazioni che devono essere costantemente sincronizzate con lo stato della View.  \\
Implementa l'interfaccia di notifica di Observer per mantenere il proprio stato consistente con quello della View.  \\
Definisce un'interfaccia comune per tutti i gestori del Model.  \\
Dichiara il metodo factory CreateElement, che restituisce un oggetto di tipo Model: in tal modo il Controller definisce un'interfaccia per creare oggetti, ma lascia alle sottoclassi la decisione del tipo di classe da istanziare. Ogni classe ha il proprio costruttore, le classi interne utilizzano quello di default.

\subsection{Controller}
Setta i messaggi di errore e rende disponibili alcune funzionalit\`a che permetto l'interfacciamento con il Model in modo semplice.

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{model:} attributo di tipo Model che consente la comunicazione con il component Model dell'MVC. La classe Model funge da Fa\c{c}ade. L'attributo dev'essere accessibile in tutto il controller.
	\item[] \textbf{error:} attributo di tipo String visibile in tutto il controller, racchiude in s\`e le chiavi per identificare gli errori provenienti dall'input degli utenti
\end{itemize}

\paragraph{Metodi}
Le variabile indicate sopra avranno il loro metodo pubblici per leggerle. Non andremo a descriverli in quanto il loro funzionamento \`e banale.

\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
convertSize(String exponent) : void			& Metodo pubblico che ritorna il valore espresso in potenza di 2 di KB,MB,GB o TB\\
\hline
dimensionPow(int dimension, int indexPow) : long	& Metodo pubblico che converte la dimensione inserita dall'utente in Byte (Esempio: 2KB = 2048)\\
\hline
\end{tabular}
\end{center}

\paragraph{Classi Interne}
Illustriamo di seguito le classi interne utilizzate per la gestione di simulazioni e progetti. 
\begin{itemize}
	\item[] \textbf{openSimulation:} Classe pubblica che implementa ActionListener e si occupa dell'apetura di una simulazione precedentemente salvata. Contiene i metodi:
	%TABELLA METODI
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per aprire una determinata simulazione.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{saveSimulation:} Classe pubblica che implementa ActionListener e si occupa del salvataggio di una simulazione. Contiene i metodi:
	%TABELLA METODI TestDimPart
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per salvare una determinata simulazione.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{openProject:} Classe pubblica che implementa ActionListener e si occupa dell'apetura di un progetto precedentemente salvata. Contiene i metodi:
	%TABELLA METODI
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per aprire un determinato progetto.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{saveProject:} Classe pubblica che implementa ActionListener e si occupa del salvataggio di un progetto. Contiene i metodi:
	%TABELLA METODI TestDimPart
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed (ActionEvent event) : void	&Metodo pubblico necessario per implementare la classe ActionListener che richiama la classe Model per salvare un determinato progetto.\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
\end{itemize}

\subsection{SimulationManager}
Estende il Controller.  \\
Conosce il modo di svolgere le operazioni associate ad una richiesta relativa ad una simulazione singola del file system appropriato.
Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.  \\
Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Simulation).

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{existError:} vettore di \texttt{boolean} che tiene traccia degli errori presenti in vista
	\item[] \textbf{panel:} attributo di tipo \texttt{SimulationPanel} che contiene il riferimento della componente della vista propria della gestione di simulazione 
	\item[] \textbf{simId:} attributo intero che identifica l'indice della simulazione nel Vector presente nella classe Model
	\item[] \textbf{busySpace:} attributo di tipo \texttt{long} che identifica l'occupazione del disco per l'inserimento di più file
\end{itemize}

\paragraph{Metodi}
La variabile simulationName indicata sopra avr\`a il suo metodo pubblici per leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.

\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
writeError() : void		& Metodo pubblico che comunica alla vista eventuali errori presenti \\
\hline
startSimulation() : void	&Metodo pubblico che richiama il Model per effettuare l'avvio della simulazione con i dati inseriti dall'utente\\
\hline
dimPart() : void		& Metodo pubblico che controlla che la dimensione della partizione sia valida\\
\hline
dimBlock() : void		& Metodo pubblico che controlla che la dimensione del blocco sia valida\\
\hline
dimFile() : void			& Metodo pubblico che controlla che la dimensione del file sia valida\\
\hline
dimMultiFile() : void		&Metodo pubblico che controlla che la dimensione del file in modalit\`a inserimento multiplo sia valida\\
\hline
setFreeSpace() : void		& Metodo pubblico che comunica alla View la massima dimensione di un file inseribile con inserimento multiplo\\
\hline
testAddFile() : void		& Metodo pubblico che richiama il Model per l'inserimento di un file in modalit\`a multipla in una simulazione\\
\hline
testDeleteFile(String fileName, String fileValue) : void & Metodo pubblico che richiama il Model per l'eliminazione di un file in modalit\`a multipla in una simulazione\\
\hline
updateError() : void		& Metodo pubblico che al cambiare della modalit\`a di inserimento file azzera gli errori causati dall'utente in input della modalit\`a precedente\\
\hline
\end{tabular}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
setBusySpace() : void		& Metodo pubblico che al caricamento di una simulazione da la possibilit\`a di aggiornare il campo dati busySpace \\
\hline
changeFileSystemType(String newType) : void		& Metodo pubblico che comunica al Model di cambiare il tipo di \underline{FS} per la simulazione \\
\hline
getExistError(int x) : boolean	& Metodo pubblico che comunica se l'errore di indice x \`e presente o meno nella simulazione \\
\hline
checkFile() : void		& Metodo pubblico che controlla se la variazione di un campo dati in comporta una non validit\`a del file inserito, in tal caso ne segnala un errore \\
\hline
validMultiFile() : boolean		& Metodo pubblico che verifica se il file inserito in modalit\`a multi file \`e valido (nome non gia presente nella simulazione e dimensioni coerenti con i dati inseriti) \\
\hline
setMaxFile(long maxLenght, String exp) : void		& Metodo pubblico che comunica alla View di aggiornare la lunghezza massima del file inseriti con i valori dati \\
\hline
\end{tabular}
\end{center}
%-------------------------INIZIO DESCRIZIONE CLASSI INTERNE--------------------------------
\paragraph{Classi Interne}
Illustriamo di seguito le classi interne utilizzate per la gestione di eventi catturati dalla vista. 
\begin{itemize}
	\item[] \textbf{TestDimPart:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione della partizione. Contiene i metodi:
	%TABELLA METODI TestDimPart
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione della partizione, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestComboDimPart:}  Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione della partizione espressa in KB, MB, GB o TB. Contiene i metodi:
	%TABELLA METODI TestComboMaxLivIndirizzamento
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la dimensione della partizione controlla la coerenza con la dimensione di un blocco e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestDimBlock:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione dei blocchi della partizione. Contiene i metodi:
	%TABELLA METODI TestDimBlock
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del blocco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

\item[] \textbf{TestComboDimBlock:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione di un blocco espressa in Byte, KB, MB o GB. Contiene i metodi:
	%TABELLA METODI TestComboDimBlock
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la dimensione di un blocco controlla la coerenza con la dimensione della partizione e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestDimFile:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione di un unico file. Contiene i metodi:
	%TABELLA METODI TestDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del file, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
\item[] \textbf{TestComboDimFile:}  Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione di un file espressa in KB, MB, GB. Contiene i metodi:
	%TABELLA METODI TestComboDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la dimensione di un file controlla se il file è di dimensione adeguata per l'inserimento nella partizione e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

\item[] \textbf{TestDimMultiFile:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la dimensione di un file in modalit\`a inserimento multiplo. Contiene i metodi:
	%TABELLA METODI TestDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del file, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

		
\item[] \textbf{TestComboDimMultiFile:}  Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la dimensione di un file in modalit\`a inserimento multiplo espressa in KB, MB, GB. Contiene i metodi:
	%TABELLA METODI TestComboDimFile
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo-box riguardante la dimensione di un file controlla se il file \`e di dimensione adeguata per l'inserimento nella partizione e se coerente richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestFragmentation:} Classe pubblica che implementa KeyListener e si occupa del controllo dei dati inseriti dall'utente riguardanti la frammentazione di un unico file espressa tramite il numero medio di blocchi contigui. Contiene i metodi:
	%TABELLA METODI TestFramm
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il numero di blocchi contigui del file, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	

	\item[] \textbf{TestDirectBlockFirstInode:} Classe pubblica che implementa KeyListener e si occupa del controllo del dati inserito dall'utente riguardante il numero di blocchi del primo i-node. Contiene i metodi:
	%TABELLA METODI TestBlockFirstInode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il numero di blocchi diretti del primo inode dell'Ext2, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestDimiNode:} Classe pubblica che implementa KeyListener e si occupa del controllo del dati inserito dall'utente riguardante la dimensione di un i-node. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione dell'inode, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	

	\item[] \textbf{TestComboFSType:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante il tipo di \underline{FS}. Contiene i metodi:
	%TABELLA METODI TestComboTipoFS
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante il tipo di \underline{FS}, effettua una conversione della simulazione e fa si che la vista si aggiorni con i campi dati propri del tipo di \underline{FS} selezionato\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{TestComboMaxAddressLevel:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante il massimo livello di indirizzamento degli i-node. Contiene i metodi:
	%TABELLA METODI TestComboMaxLivIndirizzamento
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante il livello di indirizzamento degli i-node e richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	
	\item[] \textbf{TestRotationSpeed:} Classe pubblica che implementa KeyListener e si occupa del controllo del dati inserito dall'utente riguardante la velocit\`a di rotazione del disco. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la velocit\`a di rotazione del disco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	

	\item[] \textbf{TestSeekTime:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante il tempo di latenza del disco. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il tempo di latenza del disco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	
	\item[] \textbf{TestTrack:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante il numero di blocchi per traccia del disco. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardanteil numero di blocchi per traccia del disco, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
		
	\item[] \textbf{TestMainRecord:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante la dimensione del record base del file system NTFS. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del record base, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestExtensionRecord:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante la dimensione del record di estensione del file system NTFS. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void			&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante la dimensione del record estensione, effettua un controllo sul dato inserito e se corretto richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestFileName:} Classe pubblica che implementa KeyListener e si occupa del controllo del dato inserito dall'utente riguardante il nome del file inserito. Contiene i metodi:
	%TABELLA METODI TestDimiNode
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	keyPressed(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyTyped(KeyEvent event) : void		&Metodo pubblico necessario per implementare la classe KeyListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	keyReleased(KeyEvent event) : void		&Metodo pubblico che al rilascio di un pulsante dal campo dati riguardante il nome del file, effettua un controllo sul dato inserito e se univoco richiama il Model per salvarlo nella giusta simulazione\\
	\hline
	
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestComboAllocationType:} Classe pubblica che implementa ItemListener e cattura i cambiamenti di stato della componente combo box riguardante la politica di allocazione del file. Contiene i metodi:
	%TABELLA METODI TestComboAllocationType
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void			&Metodo pubblico che al cambiamento della componente combo box riguardante la politica di allocazione del file e richiama il Model per salvare il dato nella giusta simulazione\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
	
	\item[] \textbf{TestSetAsDefault:} Classe pubblica che implementa ActionListener e imposta i valori settati dall'utente come simulazione di default 
	%TABELLA METODI testSetAsDefault
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			&Metodo pubblico che imposta i valori settati dall'utente come simulazione di default \\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{resetToDefault:} Classe pubblica che implementa ActionListener e si occupa di richimare il Model per resettare la simulazione con i voli presenti nel default. Contiene i metodi:
	%TABELLA METODI resetToDefault
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			& Metodo pubblico che ripristina i valori della simulazione di default sulla simulazione attuale \\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{showHideAdvancePannel:} Classe pubblica che implementa MouseListener e si occupa di nascondere/visualizzare la scermata a View del pannello avanzate. Contiene i metodi:
	%TABELLA METODI resetToDefault
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	mouseClicked(MouseEvent e) : void			& Metodo pubblico che nasconde/visualizza a View il pannello delle avanzate \\
	\hline
	mousePressed(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
        	\hline
 	mouseReleased(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
  	\hline
 	mouseEntered(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
  	\hline
 	mouseExited(MouseEvent e) : void 			&Metodo pubblico necessario per implementare la classe MouseListener ma non utilizzato nel sistema SiFiSy\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{startSimulation:} Classe pubblica che implementa ActionListener e si occupa di richimare il Model per calcolare i risultati di una simulazione. Contiene i metodi:
	%TABELLA METODI startSimulation
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			& Metodo pubblico che richiama il Model per avviare i calcoli per i risultati di una simulazione \\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

	\item[] \textbf{resetToDefault:} Classe pubblica che implementa ActionListener e si occupa di richimare la View per cambiare i pannelli con i varii pampi dati per i diversi \underline{FS}. Contiene i metodi:
	%TABELLA METODI swichFileSystemPanel
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	actionPerformed(ActionEvent event) : void			& Metodo pubblico che cambia il pannello con il \underline{FS} desiderato\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA

\end{itemize}

\subsection{ProjectManager}
Estende il Controller.   \\
Conosce il modo di svolgere le operazioni associate ad una richiesta relativa ad un progetto (che \`e un insieme di simulazioni).
Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.   \\
Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Project).

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{panel:} attributo privato di tipo ProjectPanel che prende le informazioni contenute nella vista.
\end{itemize}

\paragraph{Metodi}
La variabile simulationName indicata sopra avr\`a il suo metodo pubblici per leggerla. Non andremo a descriverli in quanto il loro funzionamento \`e banale.

\begin{center}
\begin{tabular}{|p{5cm}|p{6.4cm}|}
\hline
\textbf{Nome} & \textbf{Descrizione}\\
\hline
ProjectManager(String projectName, ProjectPanel panel)	& costruttore della classe ProjectManager \\
\hline
addSimulation(int simulationId) : void			& Metodo pubblico che aggiunge la simulazione di indice simId al progetto\\
\hline
removeSimulation(int simulationId) : void		& Metodo pubblico che rimuove dal progetto la simulazione identificata da simId \\
\hline
importSimulation(String filePath) : int			& Metodo pubblico che aggiunge al progetto una simulazione precedentemente salvata (identificata dal proprio path di origine) e ne ritorna l'indice della simulazione \\
\hline
startCompare() : void					& Metodo pubblico che avvia il confronto tra simulazioni del progetto\\
\hline
addCompare(int simId) : void				& Metodo pubblico che aggiunge una simulazione alla lista delle simulazioni da comparare alla start \\
\hline
removeCompare(int simId) : void			& Metodo pubblico che rimuove una simulazione dalla lista delle simulazioni da comparare alla start \\
\hline
exportPdf(String filePath) : void			& Metodo pubblico che richiama l'esportazione in pdf del progetto\\
\hline
\end{tabular}
\end{center}

%\subsection{HelpManager}
%Estende il Controller.  \\
%Conosce il modo di svolgere le operazioni associate ad una richiesta relativa ad un file di tipo Help.  \\
%Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.  \\
%Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Help).


%\paragraph{Attributi}
%Gli attributi della classe sono tutti privati.
%\begin{itemize}
%	\item[] \textbf{DA FARE:} DA FARE
%\end{itemize}

%\paragraph{Metodi}
%DA FARE

%\paragraph{Classi Interne}
%DA FARE

\subsection{PreferencesManager}
Estende il Controller. \\
Conosce il modo di svolgere le operazioni associate ad una richiesta relativa alle inpostazioni del sistema SiFiSy.  \\
Come tutte le istanze concrete del Controller, corrisponde al Receiver nel Pattern Command.  \\
Sovrascrive il Factory Method CreateElement in modo da restituire un'istanza concreta del Model appropriata (in tal caso un oggetto specifico Model).

\paragraph{Attributi}
Gli attributi della classe sono tutti privati.
\begin{itemize}
	\item[] \textbf{view:} attributo che contiene il riferimento della componente della vista propria della gestione delle impostazioni dell'applicativo SiFiSy
\end{itemize}

\paragraph{Metodi}
La classe non contiene metodi

\paragraph{Classi Interne}
Illustriamo di seguito le classi interne utilizzate per la gestione di eventi catturati dalla vista. 
\begin{itemize}
	\item[] \textbf{TestComboLanguage:} Classe pubblica che implementa ItemListener e si occupa del catturare l'azione dell'utente necessaria al cambiamento del linguaggio del sistema SiFiSy. Contiene i metodi:
	%TABELLA METODI TestComboLanguage
	\begin{center}
	\begin{tabular}{|p{4.5cm}|p{6cm}|}
	\hline
	\textbf{Nome} & \textbf{Descrizione}\\
	\hline
	itemStateChanged(ItemEvent e) : void		&Metodo pubblico che cattura il cambiamento del linguaggio da parte dell'utente e comunica al Model di caricare il linguaggio selezionato\\
	\hline
	\end{tabular}
	\end{center}
	%FINE TABELLA
\end{itemize}


\chapter{Appendice}

%\section{Codice sorgente?????????????}

\section{Tracciamento componenti - requisiti}
%Bene il tracciamento componenti � requisiti, ma manca il tracciamento inverso

\section{Componente Controller}

\subsection{Classe Controller}

\paragraph{Attributi}
 \begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
model& FB14 - FB15 - FD05 - FD06\\
\hline
error& QB02 - QP01\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\paragraph{Metodi}
 \begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
convertSize(String exponent) : void& FB01 - FB02 - FB03\\
\hline
dimensionPow(int dimension, int indexPow) : long& FB01 - FB02 - FB03\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\paragraph{Classi Intterne}
 \begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Classi Interna} & \textbf{Requisito associato}\\
\hline
openSimulation& FB14\\
\hline
saveSimulation& FB15\\
\hline
openProject& FD05\\
\hline
saveProject& FD06\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe SimulationManager}
\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
existError& QB02 - QP01\\
\hline
panel& FB01 - FB02 - FB03 - FB07 - FB08 - FB09\\
\hline

simId& FB14 - FB15\\
\hline
busySpace& FP01\\
\hline
\end{tabular}
\end{tabular}
\end{center}
 
\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
writeError() : void& QB02 - QP01\\
\hline
startSimulation() : void& FB11 - FB12 - FB13\\
\hline
dimPart() : void& FB01\\
\hline
dimBlock() : void& FB02\\
\hline
dimFile() : void& FP01 - FD04\\
\hline
dimMultiFile() : void& FP01\\
\hline
setFreeSpace() : void& FP01\\
\hline
testAddFile() : void& FP01 - FD04\\
\hline
testDeleteFile(String fileName, String fileValue) : void& FP01\\
\hline
updateError() : void& QB02 - QP01\\
\hline
setBusySpace() : void& FP01\\
\hline
changeFileSystemType(String newType) : void& FB04 - FB05 - FB06\\
\hline
getExistError(int x) : boolean& QB02 - QP01\\
\hline
checkFile() : void& FP01 - FD04\\
\hline
validMultiFile() : boolean& FP01\\
\hline
setMaxFile(long maxLenght, String exp) : void& FB11\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Classi Interni} & \textbf{Requisito associato}\\
\hline
TestDimPart& FB01\\
\hline
TestComboDimPart& FB01\\
\hline
TestDimBlock& FB02\\
\hline
TestComboDimBlock& FB02\\
\hline
TestDimFile& FB03 - FD04 - FB07 - FB08\\
\hline
TestComboDimFile& FB03 - FD04 - FB07 - FB08\\
\hline
TestDimMultiFile& FB03 - FP01\\
\hline
TestComboDimMultiFile& FB03 - FP01\\
\hline
TestFragmentation& FB08\\
\hline
TestDirectBlockFirstInode& FB09\\
\hline
TestDimiNode& FB09\\
\hline
TestComboFSType& FB04 - FB05 - FB06\\
\hline
TestComboMaxAddressLevel& FB09\\
\hline
TestRotationSpeed& FP02\\
\hline
TestSeekTime& FP03\\
\hline
TestTrack& FP04\\
\hline
TestMainRecord& FB09\\
\hline
TestExtensionRecord& FB09\\
\hline
TestFileName& FP01\\
\hline
TestComboAllocationType& FP01\\
\hline
TestSetAsDefault& FB10\\
\hline
resetToDefault&  FB10\\
\hline
showHideAdvancePannel& FP02 - FP03 - FP04 - FP05\\
\hline
startSimulation& FB11 - FB12 - FB13\\
\hline
resetToDefault& FB10\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe  ProjectManager}

 \begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
panel & FB01 - FB02 - FB03 - FB07 - FB08 - FB09\\
 \hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
addSimulation(int simulationId) : void& FD07\\
\hline
removeSimulation(int simulationId) : void& FD08\\
\hline
importSimulation(String filePath) : int& FD07\\
\hline
startCompare() : void& FD02 -  FD03\\
\hline
addCompare(int simId) : void& FD02 -  FD03\\
\hline
removeCompare(int simId) : void& FD02 -  FD03\\
\hline
exportPdf(String filePath) : void& FD09\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe PreferencesManager}

 \begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributi} & \textbf{Requisito associato}\\
\hline
view & FB01 - FB02 - FB03 - FB07 - FB08 - FB09\\
\hline
\end{tabular}
\end{tabular}
\end{center}


\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Classi Interne} & \textbf{Requisito associato}\\
\hline
TestComboLanguage& QP01\\
\hline
\end{tabular}
\end{tabular}
\end{center}


\section{Componente View}

\subsection{MainWidget}

\paragraph{Attributi}
 \begin{center}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	 FILEFILTER PDF & FD09\\
	\hline
	 FILEFILTER SIMULATION  & FB14\\
	\hline
	 FILEFILTER PROJECT  &FB15\\
	\hline
	 FILEFILTER PNG  &FD10\\
	\hline
	 simulations  & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
	\hline
	 simulationsList & FB15\\
	\hline
	 projectsList  & FB14\\
	\hline
	 tabbedPane & FD01 - FB14 - FB15\\
	\hline
	 treeView  & FB15 - FD06\\
	\hline
	mainWidgetFrame  & PB01\\
	\hline
	fileMenu  & FD05 - FD06 - FB14 - FB15\\
	\hline
	file  & FD05 - FD06 - FB14 - FB15\\
	\hline
	help  & QB01 - QP01 - QP02 - FB04\\
	\hline
	newSimulation  & VB03\\
	\hline
	newProject  & FD01\\
	\hline
	wizard  & FB10 - FD01 - FB15 - FD06\\
	\hline
	open  & FB15 - FD06\\
	\hline
	closeSimulation  & FB14\\
	\hline
	closeProject  & FD05\\
	\hline
	save   & FB14 - FD05\\
	\hline
	preferences  & QP01\\
	\hline
	exit  & FB14 - FD05\\
	\hline
	helpWizard  & QB02 - QP01 - QP02 - VB04\\
	\hline
	about  & QB02\\
	\hline
	newSimulationButton  & VB03\\
	\hline
	newProjectButton  & FD01\\
	\hline
	openButton  & FB15 - FD06\\
	\hline
	saveButton  & FB14 - FD05\\
	\hline
	helpButton  & QB02 - QP01 - QP02 - VB04\\
	\hline
	messages& QB02\\
	\hline  
	rootNode& FB14 - FB15\\
	\hline
\end{tabular}

\end{center}

 \begin{center}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
initComponents () : void & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
\underline{open} () : boolean & FB15 - FD06\\
\hline
initTreeView () : void & FB15 - FD06\\
\hline
\underline{updateTreeView} () : void & FB15 - FD06\\
\hline
\underline{getNodeIndex} (String nodeName) : int & FB15 - FD06\\
\hline
mainWidget () & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
\underline{addSimulationToTree} (SiFiSyTreeNode node) : void & FB15\\
\hline
\underline{addSimulationToTree} (SifisyTreeNode node, DefaultMutableTreeNode parentNode) : void & FB15 - FD06 - FD01\\
\hline
\underline{removeSimulation} (SimulationPanel simPanel) : void & FB14\\
\hline
removeSimulationFromList ( String name) : void & FB14\\
\hline
removeProjectFromList (String name) : void & FB06\\
\hline
\underline{showOpenFileDialog} (int fileFilter) : String & FB15 - FD06\\
\hline
\underline{showSaveFileDialog} (int fileFilter) : String & FB14 - FD05\\
\hline
\underline{createSimulation} (String simulationName) : SimulationPanel & VB03\\
\hline
\underline{createSimulation} (String simulationName, ProjectPanel panel) : SimulationPanel & FD07\\
\hline
\underline{createProject} (String projectName) : ProjectPanel & FD01\\
\hline
\underline{main} () : void & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
\end{tabular}
\end{center}

\subsection{SimulationPanel}
 \begin{center}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
 	CONFIG PANEL  & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
	 RESULTS PANEL& FB01\\
\hline
	 simulationId  & FB14 - FB15\\
\hline
	 simulationName & FB14 - FB15\\
\hline 
	 simulationManager & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
	 node  & FB14 - FB15\\
\hline
	 parentPanel  & FD07\\
\hline
	 configSimulation  & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
	 startSimulation & PB01\\
\hline
	 simulationGraphics& QB03 - FD01\\
\hline  
	 exportResults  & FD09\\
\hline
	 resetSimulation & FB10\\
\hline
	 setAsDefaultSimulation & FB10\\
\hline
	 closeSimulation  & FB14\\
\hline
	 changeFileInsertionMode  & FP01\\
\hline
	 model  & PB01\\
\hline
	 resultsPanel  & PB01\\
\hline
	 frameGraphics& QB03 - FD01\\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
initComponents () :  void & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
clearFields () : void & VB03\\
\hline
readSimulationValues () : void & FB15\\
\hline
SimulationPanel () & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10 - VB03\\ 
\hline
SimulationPanel (String name, SiFiSyTreeNode node) & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10 - VB03\\
\hline
SimulationPanel (String simName, SifisyTreeNode node, ProjectPanel parent) & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10 - VB03 - FD07\\
\hline
loadSimulationFiles () : void & FP01\\
\hline
showConfig () : void & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
showResults () : void & PB01\\
\hline
lockWindowsDialog (boolean active) : void &  FB15 - PB01\\
\hline
notifyPanel (int simId) : void & FB15 - PB01\\
\hline
notifyPanel (String message) : void & FB15 - PB01\\
\hline
notifyPanel () : void & FB15 - PB01\\
\hline
refreshFields () : void & VB03\\
\hline
\end{tabular}
\end{center}

\paragraph{Classe interna SimulationResultsPanel}
\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
 settingsTable  & PB01\\
\hline
tableModel  & PB01\\
\hline
settingsScrollPane  & PB01\\
\hline
resultsScrollPane  & PB01\\
\hline
parentPane  & PB01\\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
SimulationResultsPanel (SimulationPanel parent) &  PB01\\
\hline
initComponents () : void & PB01\\
\hline
fillResultsTable () : void & PB01\\
\hline
\end{tabular}
\end{center}

\subsection{ProjectPanel}

\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
 projectId & FD01 - FD05 - FD06\\
\hline
projectName & FD01 - FD05 - FD06\\
\hline
projectManager & FB01 - FB02 - FB03 - FB04 - FB05 - FB06 - FB07 - FB08 - FB09 - FB10\\
\hline
node & FD05 - FD06\\
\hline
panelCompare & FD02 - FD03\\
\hline
toolBar & FD02 - FD03\\
\hline
buttonAddSimulation & FD04\\
\hline
buttonClose & FD05\\
\hline
buttonImportSimulation & FD07\\
\hline
tabbedPane & FD07 - PB01\\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
initComponents () : void & FD01\\
\hline
ProjectPanel (String projectName, SifisyTreeNode node) & FD01\\
\hline
lockWindowsDialog (boolean active) : void & FD01 - FD07 - FD02 - FD03\\
\hline
notifyPanel (int projectId) : void & FD01 - FD07 - FD02 - FD03\\
\hline
notifyPanel (String message) : void & FD01 - FD07 - FD02 - FD03\\
\hline
notifyPanel () : void & FD01 - FD07 - FD02 - FD03\\
\hline
addSimulation (String simulationName, SifisyTreeNode simulationNode) : SimulationPanel & FD07\\
\hline
removeSimulation (SimulationPanel simPanel) : void & FD08\\
\hline
refreshFields () : void & FD06\\
\hline
\end{tabular}
\end{center}

\paragraph{Classe interna ProjectComparePanel}
\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
CONFIG PANEL  & FD07\\
\hline
RESULTS PANEL  & PB01\\
\hline
parentPanel  & FB14 - FB15\\
\hline
toolBar  & FD07 - PB01\\
\hline
btConfigProject  & FD07\\
\hline
btStartProject  & PB01\\
\hline
btExportPdf  & FD09\\
\hline
panelInner  & FD07\\
\hline
panelConfig  & FD07\\
\hline
listModel  & FD07\\
\hline
resultsPanel  & PB01\\
\hline
resultsTable  & PB01\\
\hline
tableModel & PB01\\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
ProjectComparePanel (ProjectPanel parentPanel) & FD01\\
\hline
initComponents () : void & FD01\\
\hline
addSimulation (int simulationId) : void & FD07\\
\hline
removeSimulation (int simulationId) : void & FD08\\
\hline
fillResultsTable () : void & PB01\\
\hline
\end{tabular}
\end{center}

\paragraph{Classe interna SifisyTableCellRenderer}
\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
cellColor & PB01 - QB03\\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
SifisyTableCellRenderer (Color cellColor) & PB01 - QB03\\
\hline
getTableCellRendererComponent (JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) : Component & PB01 - QB03\\
\hline
\end{tabular}
\end{center}

\paragraph{Classe interna SifisyTableCell}
\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
value & PB01 - QB03\\
\hline
isColored & PB01 - QB03\\
\hline
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{|p{5.3cm}|p{7cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
SifisyTableCell (String value, boolean isColored) & PB01 - QB03\\
\hline
toString () : String & PB01 - QB03\\
\hline
\end{tabular}
\end{center}

\subsection{Package Controller}
\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Componente} & \textbf{Requisito associato}\\
\hline
Controller& FB08 - FB14 - FB15 - FD01 - FD05 - FD06 - FD07 - FD08 - FP01 - FD05 - QP02\\
\hline
EvenHandle& FB08 - FB14 - FB15 - FD01 - FD05 - FD06 - FD07 - FD08 - FP01 - FD05 - QP02\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\section{Componente Model}

\subsection{Classe Model}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	simulations & FB14 - FB15\\
\hline
	project & FD05 - FD06\\
\hline
	language & QP01\\
\hline
	schemaPath & FD05 - FB14\\
\hline
	setupPath & QP01 - FB15\\
\hline
	guiTranslatePath & QP01\\
\hline
	startupScreen &  QP01\\
\hline
	getHelpPath &QB02 - QP02\\
\hline
	defaultSimulationPath & FB15\\
\hline
	changedSetup & FB15\\
\hline
 \end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
	\underline{loadSetup} () : void& QP01\\
\hline
	\underline{saveSetup} () : void& QP01\\
\hline
	\underline{translate} (String message) : String& QP01\\
\hline
	\underline{help} (String message) : String& QB02 - QP02 - VB04\\
\hline
	\underline{newSimulation} (String name, SimulationPanel panel) : void& FB15\\
\hline
	\underline{openSimulation} (String path, SimulationPanel panel) : void& FB15\\
\hline
	\underline{resetToDefault} (int simulationId, SimulationPanel panel) : void& VB03\\
\hline
	\underline{switchFileSystem} (int simulationId, String fileSystemType) : void& FB04 - FB05 - FB06\\
\hline
	\underline{saveSimulation} (int index, String path, SimulationPanel panel) : void& FB14\\
\hline
	\underline{startSimulation} (int simId, SimulationPanel panel) : void& FB11 - FB12 - FB13\\
\hline
	\underline{removeSimulation} (int simId, SimulationPanel panel) : void& FD08\\
\hline
	\underline{exportSimulationPng} (String simPath, SimulationPanel panel) throws java.io.FileNotFoundException : void& FD10\\
\hline
	\underline{exportSimulationPdf} (String simPath, SimulationPanel panel) : void& FD09\\
\hline
	\underline{newProject} (String name, ProjectPanel panel) : void& FD01\\
\hline
	\underline{addSimulation} (String simName, SimulationPanel panel, int projectId) : void& FD07\\
\hline
	\underline{openProject} (String path, ProjectPanel panel) : void& FD06\\
\hline
	\underline{saveProject} (int prjId, String path, ProjectPanel panel) : void& FD05\\
\hline
	\underline{saveAsDefault} (int simId) : void& FB10\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe Project}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	name & FD01\\
\hline
	simulationsRef	& FD07 - FD08\\
\hline
	compare	& FD02 - FD03\\
\hline
	modified	& FD05\\
\hline
	bestCompare	& FD02\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
	numberOfSimulation() : int & FD07 - FD08\\
\hline
	save(Element projectRoot) : void & FD05\\
\hline
	open(Element projectRoot) : void & FD01 - FD06\\
\hline
	addSimulation(Integer simulationId)() : void & FD07\\
\hline
	importSimulation(String filePath) : int & FD07\\
\hline
	importSimulation(String filePath, SimulationPanel panel) : void & FD07\\
\hline
	removeSimulation(int simId)() : void & FD08\\
\hline
	getSimulation(int simId) : Integer & FD07 -  FD08\\
\hline
	addCompare(Integer SimId) : void & FD07 -  FD08\\
\hline
	removeCompare(Integer simId) : void & FD07 -  FD08\\
\hline
	compare() : void & FD02 -  FD03\\
\hline
	compareOverhead() : void & FD02 -  FD03\\
\hline
	compareMaxLenghtFile() : void & FD02 -  FD03\\
\hline
	compareFileSystem() : void & FD02 -  FD03\\
\hline
	compareInternalFragmentation() :  & FD02 -  FD03\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe Simulation}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	simName & FB10\\
\hline
	files & FP01\\
\hline
	usedBlocks & FB08\\
\hline
	partitionDimension & FB01\\
\hline
	partitionExponent & FB01\\
\hline
	blockDimension & FB02\\
\hline
	blockExponent	& FB02\\
\hline
	addressDimension & FB11 -  FB12 -  FB13\\
\hline
	fileAllocationType & FP01\\
\hline
	allocationNextIndex & FP01\\
\hline
	rotationSpeed	& FP02\\
\hline
	trackPercent & FP04\\
\hline
	seekTime & FP03\\
\hline
	trackSectors & FP04\\
\hline
	maxLenghtFile	& FB11\\
\hline
	internalFragmentation	& FB12 -  FB13\\
\hline
	inflationIndex	& FB12 -  FB13\\
\hline
	averageReading & FP05\\
\hline
	sizeFileSystem	& FB12 -  FB13\\
\hline
	modifiedCamps & FB14\\
\hline
	chooseAdvanced & FB05\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
	\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
	save(Element simulationRoot) : void & FB14\\
\hline
	single(Section item) : void & FB08\\
\hline
	insParts(Section section) :  & FB08\\ 
\hline
	calculateRandomSpace() : long & FB08\\
\hline
	start()	: void & FB11 -  FB12 -  FB13\\
\hline
	open(Element simulationRoot) : void & FB15\\
\hline
	addFile(File item) : void &  FP01\\
\hline
	breakFile(File item) : void & FB08\\
\hline
	deleteFile(String ID) : void & FP01\\
\hline
	deleteParts(File item) : void & FP01\\
\hline
	viewMaxFile()	: void & FB11 - FB12 - FB13\\
\hline
	calculateAddressDimension() : void & FB11 - FB12 - FB13\\
\hline
	\underline{getNearestTwoPow}(int address) : int & FB11 - FB12 - FB13\\
\hline
	\underline{getNearestExponentOfTwo}(double address) : int & FB11 - FB12 - FB13\\
\hline
	calculateBlockNumber() : int & FB11 - FB12 - FB13\\
\hline
	fragAverage() : double & FB08\\
\hline
	calculateFileFragmentation(long sizeFile) : double & FB08\\
\hline
	firstFit(Section item) : void & FP01\\
\hline
	bestFit(Section item) : void & FP01\\
\hline
	worstFit(Section item) : void & FP01\\
\hline
	nextFit(Section item) : void & FP01\\
\hline
	findSpace(int first, int last, int spaceNedded) : long & FP01\\
\hline
	readingTime() : double & FP05\\
\hline

\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe Ext2}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	addressLevel	& FB09 - FB10\\
\hline
	firstInodeDirectBlock	& FB09 - FB10\\
\hline
	inodeDimension	& FB09 - FB10\\
\hline
	inodeNumberMaxFile	& FB09 - FB10\\
\hline
	usedInodeNumber	& FB09 - FB10\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
	save(Element simulationRoot) : void & FB14\\
\hline
	getInodeNumber(long sizeFile) : long & FB11 - FB12\\
\hline
	calculateMaxFile() : int & FB11\\
\hline
	inflationIndex(long sizeFile) : double & FB12 - FB13\\
\hline
	inflactionIndexAverage() : double & FB12- FB13\\
\hline
	fileSystemDimension() : long & FB12- FB13\\
\hline
	start() : void & FB11 - FB12- FB13\\
\hline
	open(Element simulationRoot) : void & FB15\\
\hline
	viewMaxFile()	: void & FB11\\
\hline

	getConfigurationValues() : Vector & FB01- FB02 - FB03 - FB09\\
\hline
	getResultsValues() : Vector & FB11 - FB12- FB13\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe Fat32}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	records & FB09 - FB10\\
\hline
	sizeFileSystem	& FB09 - FB10\\
\hline
	maxPartitionSize & FB09 - FB10\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
open(Element simulationRoot) : void & FB15\\
\hline
save(Element simulationRoot) : void & FB14\\
\hline
start() : void & FB11 - FB12 - FB13\\
\hline
inflationIndex(long sizeFile) : double & FB12 - FB13\\
\hline
getFileMaxSize() : double & FB11\\
\hline
getFat32Dim() : double & FB11 - FB12 - FB13\\
\hline
viewMaxFile()	: void & FB11\\
\hline
getConfigurationValues() : Vector & FB01 - FB02 - FB03 - FB09\\
\hline
getResultsValues() : Vector & FB11 - FB12 - FB13\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe Ntfs}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	baseRecord & FB09 - FB10\\
\hline
	extensionRecord & FB09 - FB10\\
\hline
	baseRecordCouples & FB09 - FB10\\
\hline
	extensionRecordCouples & FB09 - FB10\\
\hline
	recordsOccupied & FB09 - FB10\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
inflactionIndexAverage() : double & FB12 - FB13\\
\hline
fileSystemDimension() : int & FB12 - FB13\\
\hline
start() : void & FB11 - FB12 - FB13\\
\hline
getRecordsNumber(String id) : int & FB11 - FB12 - FB13\\
\hline
calculateAddress(long partDimension) : int & FB11 - FB12 - FB13\\
\hline
open(Element simulationRoot) : void & FB15\\
\hline
save(Element simulationRoot) : void & FB14\\
\hline
viewMaxFile()	: void & FB11\\
\hline
getConfigurationValues() : Vector &  FB01 - FB02 - FB03 - FB09\\
\hline
getResultsValues() : Vector & FB11 - FB12 - FB13\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe File}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
 	id & FP01\\
\hline
	dimension & FP01\\
\hline
	exponent & FP01\\
\hline
	averageBlocks & FB07\\
\hline
	selectedAdvanced & FP01\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Metodo} & \textbf{Requisito associato}\\
\hline
	getSize() : long & FP01\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Classe Section}

\begin{center}
\begin{tabular}{l}
\begin{tabular}{|p{5.3cm}|p{7.0cm}|}
\hline
\textbf{Attributo} & \textbf{Requisito associato}\\
\hline
	id & FP01\\
\hline
	first & FP01\\
\hline
	length & FP01\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\section{Tracciamento requisiti - componenti}

\subsection{Requisiti Funzionali}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti Funzionali}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	FB01& View - Model\\
\hline
	FB02& View - Model\\
\hline
	FB03& View - Model\\
\hline
	FB04& View - Model\\
\hline
	FB05& View - Model\\
\hline
	FB06& View - Model\\
\hline
	FB07& View - Model\\
\hline
	FB08& View - Model - Controller\\
\hline
	FB09& View - Model\\
\hline
	FB10& View - Model\\
\hline
	FB11& View  \\
\hline
	FB12& View  \\
\hline
	FB13& View  \\
\hline
	FB14& View - Model - Controller\\
\hline
	FB15& View - Model - Controller\\
\hline
	FD01& View - Model - Controller \\
\hline
	FD02& View - Model\\
\hline
	FD03& Model\\
\hline
	FD04& View  \\
\hline
	FD05& View - Model - Controller\\
\hline
	FD06& View - Controller\\
\hline
	FD07& View - Controller\\
\hline
	FD08& View - Controller\\
\hline
	FD09& View  \\
\hline
	FD10& View  \\
\hline
	FP01& View - Model - Controller \\
\hline
	FD02& View - Model\\
\hline
	FD03& View - Model \\
\hline
	FD04& View - Model\\
\hline
	FD05& Controller \\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Requisiti Prestazionali}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti Prestazionali}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	PB01& View \\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Requisiti di qualit\`{a}}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti di qualit\`{a}}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	QB01&\\
\hline
	QB02& View - Model\\
\hline
	QB03& View \\
\hline
	QP01& Model\\
\hline
	QP02& View - Controller\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\subsection{Requisiti di vincolo}
\begin{center}
\begin{tabular}{l}
{\textbf{Requisiti di vincolo}} \\
\begin{tabular}{|p{3.0cm}|p{9.3cm}|}
\hline
	\textbf{Requisito} & \textbf{Componente associato}\\
\hline
	VB01& \\
\hline
	VB02&\\
\hline
	VB03& Model\\
\hline
	VB04& View -  Model\\
\hline
\end{tabular}
\end{tabular}
\end{center}

\end{document}                                                          